卷积神经网络构建的python基础-详细理解（Pytorch）

一、python中的类（构建网络所用到的）

    我们经常看见网络构建中包含如下结构

class simpleconv(nn.Module):
    def __init__(self, nclass):
         ...                ....
    def forward(self, x):

1、python构建一个简单的类

    我们知道每个类都有自己的属性和方法，如下面的代码name以及age是类的属性，而greet()是他的方法。

class Person:
    # 属性
    name = '张三'
    age = 20

    # 方法
    def greet(self):
        print('你好, 我的名字是:{},我的年龄是:{}'.format(self.name,self.age))

    那么我们可以通过实例化这个类来调用里面的方法

p1 = Person() # 初始化一个类的对象
p1.greet() # 调用类中的方法

# 得到的结果
>>你好, 我的名字是:张三,我的年龄是:20

    这便是类的构建以及方法的调用，但是我们发现方法greet()中含有self，那么这又是什么呢，

2、python中的self

    self的含义是代表自身的意思，即初始化时先实例化自己，即self永远指向创建的实例本身，这里给一篇博客的地址，讲解的十分详细，Python中self的解释。那么上面的self初始化的其实就是类中的属性，这也是python中的固定格式。

3、python中的__init__方法

    _ init _ 是 Python 中的特殊方法，它具有如下特点：
        (1).初始化对象，每次实例被创建时最先被调用的函数。
        (2)第一个参数永远是 self，指向创建的实例本身

如下代码，加入_ init _ 方法可以使得初始化更加的方便。

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # 方法
    def greet(self):
        print('你好, 我的名字是:{},我的年龄是:{}'.format(self.name,self.age))

# 初始化一个类的对象
p1 = Person("张三",20)
# 调用类中的方法
p1.greet()

#结果
>>你好, 我的名字是:张三,我的年龄是:20

4、python中的继承

关于python中的继承下面只介绍以下几点，比较常规的就不解释了，另外，如果后面遇到其它的还会持续进行补充
如下代码类 son(father) 表示继承父类

class father
   ...
class son(father)
   ...

(1)继承父类中_init_()方法

可以在子类的_init_()方法中通过super()这个方法继承来自父类的_init_()，当然也可以进行添加

class faPerson:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 方法
    def greet(self):
        print('父亲的姓名:{},年龄:{}'.format(self.name, self.age))


class sonPerson(faPerson):
    def __init__(self, name, age, local):
        super().__init__(name, age)  # 调用父类的__init__()这个方法
        self.local = local

    def sonlocal(self):
        print('我们住在：{}'.format(self.local))


a = sonPerson('张三', 20, "北京")
a.greet()
a.sonlocal()

#输出结果
>>父亲的姓名:zhangsan,年龄:20
>>我们住在：北京

5、pytorch网络中forward()函数

这里与python中的__ call _()函数有关，那么接下来理解一下_ call ()这个函数， call __()函数的作用是让python中的类的对象能够像方法一样被调用，下面是一个例子

class Print(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __call__(self, age):
        self.age = age
        print('我的年龄是：{}岁'.format(self.age))
    def greet(self):
        print('我的姓名:{},年龄:{}'.format(self.name, self.age))
        
instance = Print("张三", 20)
>>我的年龄是：20岁
instance(20)
>>我的年龄是：20岁
instance.greet()
>>我的姓名:张三,年龄:20

    Pytorch中的forward()函数被嵌套在了__ call __()这个函数当中，因此在网络调用时直接初始化网络，会直接执行forward()这个函数里面的内容。
    这里参考的是知乎上这篇文章
    #深入探究# PyTorch中的 forward() 方法详解
那么到这里，构建卷积神经网络的python基础(主要是类和对象)就结束了，关于网络的构建参考我的这篇文章
    卷积神经网络实战——表情识别（Pytorch）含Pyqt5的可操作界面

二、补充

1、iter()和_next_()方法

    这个方法也是编程中常常用到的方法，下面是它的适用场景，
    在某些情况下，我们希望实例对象可被用于for…in循环，这时我们需要在类中定义_iter_()和_next_()方法。
        (1)_iter_()返回的是一个迭代器的对象，实际上就是一个实现了_next_()的对象
        (2)next()配合_iter_()来使用的普通一个函数方法
    实际上来讲先通过内置函数 _iter_() 获得一个迭代器，然后再不断调用 _next_() 函数实现
如下给出代码

class MyRange(object):
    def __init__(self, high):
        self.low = 0
        self.high = high

    def __iter__(self):
        return self

    def __next__(self):
        if self.low < self.high:
            n = self.low
            self.low += 1
            return n
        else:
            raise StopIteration
a = MyRange(5)
for i in a:
    print(i)
#结果
>>0
>>1
>>2
>>3
>>4

    如上述代码 _iter_()进行迭代不断调用_next_()进行输出
    这里再补充一下Iterable与Iterator这几个概念：
        (1)Iterable：有迭代能力的对象_iter_()
        (2)Iterator：同时实现了_iter_()和_next_()的对象
给出代码

class B(object):
    def __next__(self):
        raise StopIteration

class A(object):
    def __iter__(self):
        return B()

from collections.abc import *

a = A()
b = B()
print(isinstance(a, Iterable))
print(isinstance(a, Iterator))
print(isinstance(b, Iterable))
print(isinstance(b, Iterator))

#结果
>>True
>>False
>>False
>>False

结尾希望大家点个赞多多支持我一下，文章还会根据后面的学习进行陆续更新。

2、_getitem _ ()方法

在定义自己的数据封装时常用的方法，与_iter_()和_next_()方法使用类似，在一些情况下可以替代。下面只展示例子，详情请看下面这个作者的文章。PYTHON 中__GETITEM__ 和 _ ITER_ 的区别

class MyRange(object):
    def __init__(self, high):
        self.low = 0
        self.high = high

    def __getitem__(self, index):
        if self.low < self.high:
            n = self.low
            self.low += 1
            return n
        else:
            raise StopIteration

a = MyRange(5)
for i in a:
    print(i)

#结果
>>0
>>1
>>2
>>3
>>4

3、_len _ ()方法

我们所熟知的len()(获取集合长度的函数)就是通过调用对象的__len__方法来工作，数据封装时可以写入该函数，这样我们可以获得数据的数量。

class MyRange(object):
    def __init__(self, high):
        self.low = 0
        self.high = high
        self.list = []

    def __getitem__(self, index):
        if self.low < self.high:
            n = self.low
            self.list.append(n)
            self.low += 1
            return n
        else:
            raise StopIteration
    def __len__(self):
        return len(self.list)

a = MyRange(5)
print(len(a))
>0
>1
>2
>3
>4
>5